package com.operator.Activitys.activity;

import android.Manifest;
import android.app.Activity;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.graphics.Color;
import android.net.Uri;
import android.os.Build;
import android.os.Bundle;
import android.os.Environment;
import android.os.Handler;
import android.provider.MediaStore;
import android.support.annotation.NonNull;
import android.support.v4.app.ActivityCompat;
import android.support.v4.content.ContextCompat;
import android.support.v4.content.FileProvider;
import android.text.TextUtils;
import android.view.Gravity;
import android.view.KeyEvent;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.ImageView;
import android.widget.TextView;

import com.afollestad.materialdialogs.DialogAction;
import com.afollestad.materialdialogs.MaterialDialog;
import com.baidu.ocr.sdk.OCR;
import com.baidu.ocr.sdk.OnResultListener;
import com.baidu.ocr.sdk.exception.OCRError;
import com.baidu.ocr.sdk.model.IDCardParams;
import com.baidu.ocr.sdk.model.IDCardResult;
import com.baidu.ocr.sdk.model.Word;
import com.baidu.ocr.ui.camera.CameraActivity;
import com.facebook.drawee.view.SimpleDraweeView;
import com.google.gson.Gson;
import com.jaredrummler.materialspinner.MaterialSpinner;
import com.operator.Activitys.R;
import com.operator.Activitys.activity.base.BaseActivity;
import com.operator.Activitys.bean.Iccid;
import com.operator.Activitys.bean.IdCard;
import com.operator.Activitys.bean.OrderPayState;
import com.operator.Activitys.bean.OrderState;
import com.operator.Activitys.bean.State;
import com.operator.Activitys.bean.UploadImage;
import com.operator.Activitys.bean.User;
import com.operator.Activitys.dialog.PopEnterPassword;
import com.operator.Activitys.http.manager.HomeManager;
import com.operator.Activitys.http.manager.UserManager;
import com.operator.Activitys.listener.OnDoubleClickListener;
import com.operator.Activitys.utils.Constant;
import com.operator.Activitys.utils.FileUtils;
import com.operator.Activitys.utils.FrescoUtils;
import com.operator.Activitys.utils.JumperUtils;
import com.operator.Activitys.utils.LogUtils;
import com.operator.Activitys.utils.ToastUtils;
import com.operator.Activitys.view.ProcessImageView;
import com.yalantis.ucrop.UCrop;
import com.zhy.autolayout.AutoRelativeLayout;

import org.simple.eventbus.EventBus;
import org.simple.eventbus.Subscriber;
import org.simple.eventbus.ThreadMode;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import butterknife.Bind;
import butterknife.OnClick;
import io.github.lizhangqu.coreprogress.ProgressHelper;
import io.github.lizhangqu.coreprogress.ProgressUIListener;
import okhttp3.Call;
import okhttp3.Callback;
import okhttp3.MediaType;
import okhttp3.MultipartBody;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;

import static com.operator.Activitys.utils.Constant.REQUEST_CAMERA_PHOTO;
import static com.operator.Activitys.utils.Constant.REQUEST_ID_CARD_CAMERA;

/**
 * 项目名称：金泽云 手机app
 * 类描述：联通、170卡 Activity
 * 创建人：张飞祥
 * 创建时间：2018/5/3 15:31
 * 修改人：张飞祥
 * 修改时间：2018/5/3 15:31
 * 修改备注：
 */
public class UnicomCardActivity extends BaseActivity {

    //返回按钮
    @Bind(R.id.iv_return)
    ImageView ivReturn;
    //标题
    @Bind(R.id.tv_title)
    TextView tvTitle;
    //开卡卡号
    @Bind(R.id.tv_card_number)
    TextView tvCardNumber;
    //开卡类型
    @Bind(R.id.tv_card_type)
    TextView tvCardType;

    //本人持卡
    @Bind(R.id.sv_card_hand)
    SimpleDraweeView svCardHand;
    @Bind(R.id.pv_card_hand)
    ProcessImageView pvCardHand;
    //正面 + 卡
    @Bind(R.id.sv_card_positive)
    SimpleDraweeView svCardPositive;
    @Bind(R.id.pv_card_positive)
    ProcessImageView pvCardPositive;
    //反面 + 卡
    @Bind(R.id.sv_card_relative)
    SimpleDraweeView svCardRelative;
    @Bind(R.id.pv_card_relative)
    ProcessImageView pvCardRelative;

    //iccid 选择
    @Bind(R.id.spinner_number_iccid)
    MaterialSpinner spinnerNumberIccid;
    //留言内容
    @Bind(R.id.et_card_info)
    EditText etCardInfo;
    //价格总布局
    @Bind(R.id.layout_card_show_money)
    AutoRelativeLayout layoutCardShowMoney;
    //价格显示隐藏布局
    @Bind(R.id.layout_card_money)
    AutoRelativeLayout layoutCardMoney;
    //温馨提示 信息
    @Bind(R.id.tv_prompt)
    TextView tvPrompt;
    //价格
    @Bind(R.id.tv_card_money)
    TextView tvCardMoney;
    //确认按钮
    @Bind(R.id.btn_card_submit)
    Button btnCardSubmit;



    //获取传递 标记
    private int mUnicomTitleTag;
    //当前运营商
    private String mUnicomOperator = "";
    //获取传递 套餐 标题
    private String mSetMealTitle;
    //获取传递 手机号码
    private String mPhoneNumber;
    //获取传递 手机号码 价格
    private double mPrice = 0;

    //价格双击 标记
    private boolean mMoneyFlag = true;

    //TODO 图片 获取
    //身份证 正面 本地图片名称
    private String mIdCardFrontPath = "unicomIdCardFront.jpg";
    //身份证 反面 本地图片名称
    private String mIdCardBackPath = "unicomIdCardBack.jpg";
    //图片路径
    private String mPhotoPath;
    //SD卡路径
    private String mSdPath;
    //拍照返回 文件路径
    private File mAvatarFile;
    //图片存储 文件路径
    private File mFileUri;
    //判断 拍照 图片获取放到那个 控件上
    private int mPhotoTag = 0;

    //TODO http 三张图片 上传 返回 具体的 Src
    private String mPeoPleSrc = "", mFrontSrc = "", mBackSrc = "";

    //TODO 身份证信息
    private IdCard mIdCard = new IdCard();

    //TODO 当前用户信息
    private User mACacheUser = null;

    //订单 初始化网络请求
    public HomeManager mApiHomeManager;
    //支付 初始化网络请求
    public UserManager mApiUserManager;

    //当前选择的 iccid
    private String mIccid = "";

    //获取内存中号卡提示信息
    private String mPrompt = "";

    //支付 弹窗
    private PopEnterPassword mPopPayPwd = null;
    //订单返回结果
    private OrderState mOrderState = null;

    //当前订单是否已经支付过了
    private boolean mOrderFlag = false;

    @Override
    protected void initUI() {
        setContentView(R.layout.act_unicom_card);
        //网络请求接口 常驻方法
        mApiHomeManager = mApiHomeManager.getHomeApiManager(this, this.getTaskId());
        //网络请求接口 常驻方法
        mApiUserManager = mApiUserManager.getUserApiManager(this, this.getTaskId());

        //设置状态栏为透明
        setThemeTransparent();

        //TODO 获取内存用户实体
        Gson gson = new Gson();
        mACacheUser = gson.fromJson(mACache.getAsJSONObject(Constant.CACHE_USER) + "", User.class);

        //TODO 获取内存中 宽带提示信息
        mPrompt = mACache.getAsString(Constant.CACHE_LOGIN_PHONE_ORDER_MSG);
        //设置温馨提示
        tvPrompt.setText(mPrompt);

        //TODO  获取传递过来的 Key
        Bundle bundle = this.getIntent().getExtras();
        if (bundle != null) {
            //联通、170卡 tag
            mUnicomTitleTag = bundle.getInt(Constant.INTENT_SALE_TAG);
            //套餐标题
            mSetMealTitle = bundle.getString(Constant.INTENT_SALE_TITLE);
            //手机号码
            mPhoneNumber = bundle.getString(Constant.INTENT_SALE_PHONE_NUMBER);
            //手机号码 价格
            mPrice = bundle.getDouble(Constant.INTENT_SALE_PRICE);

            //设置 开卡卡号
            tvCardNumber.setText(mPhoneNumber);
            //设置 号卡类型
            tvCardType.setText(mSetMealTitle);
            //设置 号卡价格
            tvCardMoney.setText("￥" + mPrice + " 元");

            //TODO 设置标题
            if (mUnicomTitleTag == 0) {
                tvTitle.setText("联通卡");
                mUnicomOperator = "联通";
            } else {
                tvTitle.setText("170卡");
                mUnicomOperator = "170";
            }

        }
        //显示返回按钮
        ivReturn.setVisibility(View.VISIBLE);
    }

    @Override
    protected void initData() {
        //TODO 双击 动态显示 价格
        initShowOrHideMoney();
        //TODO 开网络请求 获取 iccid
        mApiHomeManager.homeIccidList(mUnicomOperator,mACacheUser.getId(),mPhoneNumber);
    }

    /**
     * 双击 显示 或 隐藏 价格视图
     */
    private void initShowOrHideMoney() {
        //双击监听事件
        layoutCardShowMoney.setOnTouchListener(new OnDoubleClickListener(new OnDoubleClickListener.DoubleClickCallback() {
            @Override
            public void onDoubleClick() {
                if (mMoneyFlag) {
                    layoutCardMoney.setVisibility(View.VISIBLE);
                    mMoneyFlag = false;
                } else {
                    layoutCardMoney.setVisibility(View.INVISIBLE);
                    mMoneyFlag = true;
                }
            }
        }));
    }

    /**
     * 按钮点击事件
     *
     * @return
     */
    @OnClick({R.id.iv_return, R.id.btn_card_submit,
            R.id.layout_card_hand, R.id.layout_card_positive, R.id.layout_card_relative,})
    public void onClick(View view) {
        switch (view.getId()) {

            case R.id.iv_return:             //返回按钮
                finish();
                break;

            case R.id.layout_card_hand:      //本人手持
                if (mPhotoTag == 0){
                    mPhotoTag = 1;
                    //开始拍照
                    getImageFromPhoto();
                }else{
                    ToastUtils.showShort(UnicomCardActivity.this,"正在有图片上传，请稍等...");
                }
                break;

            case R.id.layout_card_positive:  //正面 + 卡
                if (mPhotoTag == 0){
                    mPhotoTag = 2;
                    //开始进行 身份证识别
                    getRecIdCard(CameraActivity.CONTENT_TYPE_ID_CARD_FRONT);
                }else{
                    ToastUtils.showShort(UnicomCardActivity.this,"正在有图片上传，请稍等...");
                }
                break;

            case R.id.layout_card_relative:  //反面 + 卡
                if (mPhotoTag == 0){
                    mPhotoTag = 3;
                    //开始进行 身份证识别
                    getRecIdCard(CameraActivity.CONTENT_TYPE_ID_CARD_BACK);
                }else{
                    ToastUtils.showShort(UnicomCardActivity.this,"正在有图片上传，请稍等...");
                }
                break;

            case R.id.btn_card_submit:       //确认按钮
                initHttpUnicomSubmit();
                break;
        }
    }


    /**
     * 调用 身份识别
     */
    private void getRecIdCard(String key) {
        //创建 跳转事件
        Intent intent = new Intent(this, CameraActivity.class);
        //保存图片位置
        File filePath = null;
        //传入图片存储目录
        if (CameraActivity.CONTENT_TYPE_ID_CARD_FRONT.equals(key)) {        //正面
            filePath = FileUtils.getSaveFile(getApplication(), mIdCardFrontPath);
        } else if (CameraActivity.CONTENT_TYPE_ID_CARD_BACK.equals(key)) {  //反面
            filePath = FileUtils.getSaveFile(getApplication(), mIdCardBackPath);
        }
        intent.putExtra(CameraActivity.KEY_OUTPUT_FILE_PATH, filePath.getAbsolutePath());
        //传入 身份证 type（正面 | 反面）
        intent.putExtra(CameraActivity.KEY_CONTENT_TYPE, key);
        //开始跳转
        startActivityForResult(intent, REQUEST_ID_CARD_CAMERA);
    }

    /**
     * 调用系统相机
     */
    private void getImageFromPhoto() {

        /**
         * 动态申请权限 否则不调用相机
         *
         * true： --------> 让用户手动设置 给予权限
         * flase：--------> 调用系统相机
         *
         */
        String[] PERMISSIONS_STORAGE = {
                Manifest.permission.READ_EXTERNAL_STORAGE,
                Manifest.permission.WRITE_EXTERNAL_STORAGE
        };
        int permission = ActivityCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE);
        if (permission != PackageManager.PERMISSION_GRANTED) {
            ActivityCompat.requestPermissions(this, PERMISSIONS_STORAGE, Constant.REQUEST_EXTERNAL_STORAGE);
        } else {

            //获取SD卡的路径
            mSdPath= Environment.getExternalStorageDirectory().getPath() + "/OperatorImage/";
            //获取SD卡路径 文件流
            File file=new File(mSdPath);
            if(!file.exists()){
                boolean result=file.mkdir();
                if(!result){
                    mSdPath=Environment.getExternalStorageDirectory().getPath()+"/";
                }
            };

            //设置 图片存放路径 + 文件名
            mPhotoPath = mSdPath + String.valueOf(System.currentTimeMillis()) + ".jpg";
            //获取 图片存放 文件流
            mFileUri = new File(mPhotoPath);

            //TODO 创建 页面跳转 事件
            Intent intentCamera = new Intent();
            //TODO 判断当前版本 ，设置 文件获取方式
            Uri imageUri;
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
                imageUri = FileProvider.getUriForFile(this, Constant.APP_CAMERA_APTH, mFileUri);
            } else {
                imageUri = Uri.fromFile(mFileUri);
            }
            //设置拍照方向
            intentCamera.setAction(MediaStore.ACTION_IMAGE_CAPTURE);
            //设置存储路径
            intentCamera.putExtra(MediaStore.EXTRA_OUTPUT, imageUri);
            //跳转 系统拍照页面
            startActivityForResult(intentCamera, REQUEST_CAMERA_PHOTO);
        }
    }

    /**
     * 提交号卡信息
     */
    private void initHttpUnicomSubmit() {

        //留言
        String remark = etCardInfo.getText().toString();

        //当前用户余额
        double shopMoney = mACacheUser.getRemainder();

        /**
         * 判断 店铺 是否被冻结
         *
         * 未冻结：可以支付当前订单
         *
         *      判断 支付密钥是否为空
         *
         *          非空的： 则直接 开启支付
         *
         *                  判断 1.iccid 是否为空
         *                       2.是否上传身份证手持图片
         *                       3.是否上传身份证正面图片
         *                       4.是否上传身份证背面图片
         *                       5.判断当前余额是否 可以 支付当前订单，不可以直接跳转 充值页面
         *                       6.判断当前是否 提交过订单了，提交过了 直接弹出 支付软件盘
         *                       7.已上 都不是 的情况下 则直接 进行 网络请求
         *          是空的： 跳转 设置 支付密码
         *
         * 已冻结：不可以支付当前订单了
         *
         */
        if (Constant.SHOP_STATE_YES.equals(mACacheUser.getState())) {
            if (mACacheUser.getTsPwd() != null  && !mACacheUser.getTsPwd().equals("")) {
                if (mIccid.equals("")) {
                    ToastUtils.showShort(this, "当前号码还没有仅供选择的 “ICCID” ！");
                } else if (mPeoPleSrc.equals("")) {
                    ToastUtils.showShort(this, "请上传本人近身照！");
                } else if (mFrontSrc.equals("")) {
                    ToastUtils.showShort(this, "请上传身份证正面图片！");
                } else if (mBackSrc.equals("")) {
                    ToastUtils.showShort(this, "请上传身份证背面图片！");
                } else if (shopMoney < mPrice){
                    //弹出提示
                    ToastUtils.showShort(this, "余额不足，请充值！");
                    //跳转 充值页面
                    JumperUtils.JumpTo(UnicomCardActivity.this, RechargeActivity.class);
                }else if (mOrderFlag){
                    //弹出支付软件盘
                    setShowPayPopupView("号卡订单支付", mOrderState.getPrice());
                }else {
                    //显示进度弹窗
                    initShowTimeDialog("正在提交开卡办理订单，请稍后....", this);
                    //开始网络请求
                    mApiHomeManager.homeUnciomSubmit(mACacheUser.getId(), mSetMealTitle, mIdCard.getName(),
                            mPrice, remark, mUnicomOperator, mPhoneNumber, mIdCard.getId(), mIccid, "否",
                            mIdCard.getAddress(), mIdCard.getBirthday(), mIdCard.getTerm(), mIdCard.getIssue(), mIdCard.getNation(),
                            mIdCard.getSex(), mBackSrc, mFrontSrc, mPeoPleSrc, "");
                }
            }else {
                //弹出提示
                ToastUtils.showShort(UnicomCardActivity.this,"请先设置您的支付密码！");
                //跳转设置支付密码页面
                JumperUtils.JumpTo(UnicomCardActivity.this, PayManageActivity.class);
            }
        }else {
            ToastUtils.showShort(UnicomCardActivity.this, getResources().getString(R.string.shop_state_no));
        }
    }


    /**
     * 图片处理返回页面
     *
     * @param requestCode
     * @param resultCode
     * @param data
     */
    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);

        //TODO 身份证 图片获取
        if (requestCode == REQUEST_ID_CARD_CAMERA ) {
            /**
             * 这里判断下 是否确认 相应的图片
             * true： 直接跳到裁剪，开始上传
             * false：则初始化 图片上传 Tag
             */
            if (data != null && resultCode == Activity.RESULT_OK) {
                //获取身份证正反面 type
                String contentType = data.getStringExtra(CameraActivity.KEY_CONTENT_TYPE);
                //保存图片位置
                File file = null;

                //TODO  判断 type 是否为空
                if (!TextUtils.isEmpty(contentType)) {
                    //识别 身份证信息
                    if (CameraActivity.CONTENT_TYPE_ID_CARD_FRONT.equals(contentType)) {        //正面
                        //获取 身份证 正面 图片文件
                        file = FileUtils.getSaveFile(getApplication(), mIdCardFrontPath);
                        //识别身份信息
                        recIDCard(IDCardParams.ID_CARD_SIDE_FRONT, file.getAbsolutePath());
                    } else if (CameraActivity.CONTENT_TYPE_ID_CARD_BACK.equals(contentType)) {  //反面
                        //获取 身份证 正面 图片文件
                        file = FileUtils.getSaveFile(getApplication(), mIdCardBackPath);
                        //识别身份信息
                        recIDCard(IDCardParams.ID_CARD_SIDE_BACK, file.getAbsolutePath());
                    }
                }
            }else{
                mPhotoTag = 0;
            }
        }

        //TODO 拍照图片 获取
        if (requestCode == REQUEST_CAMERA_PHOTO) {
            /**
             * 这里判断下 是否确认 相应的图片
             * true： 直接跳到裁剪，开始上传
             * false：则初始化 图片上传 Tag
             */
            if (resultCode == Activity.RESULT_OK){
                //相机返回结果，调用系统裁剪
                mAvatarFile = new File(mPhotoPath);

                //TODO 传递到图片裁剪器
                /**
                 * 需要裁剪的图片路径
                 */
                Uri sourceUri = null;
                //TODO 动态申请路径
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
                    sourceUri = FileProvider.getUriForFile(this, Constant.APP_CAMERA_APTH, mAvatarFile);
                } else {
                    sourceUri = Uri.fromFile(mAvatarFile);
                }

                //裁剪完毕的图片存放路径
                Uri destinationUri = Uri.fromFile(new File(Environment.getExternalStorageDirectory(), String.valueOf(System.currentTimeMillis()) + ".jpg"));

                //TODO 创建 裁剪参数
                UCrop uCrop = UCrop.of(sourceUri, destinationUri);
                UCrop.Options options = new UCrop.Options();
                //自定义 裁剪 比例
//                uCrop.withAspectRatio(3, 2);
                //原始比例
                uCrop.useSourceImageAspectRatio();
                //是否能调整裁剪框
                options.setFreeStyleCropEnabled(true);
                //标题栏颜色
                options.setToolbarColor(ContextCompat.getColor(this, R.color.colorPrimary));
                //设置状态栏颜色
                options.setStatusBarColor(ActivityCompat.getColor(this, R.color.colorPrimaryDark));
                //标题栏 按钮颜色
                options.setToolbarWidgetColor(ContextCompat.getColor(this, R.color.color_bg_white));
                //底部控件 按钮颜色
                options.setActiveWidgetColor(ContextCompat.getColor(this, R.color.color_bg_blue));
                //圆形裁剪
                options.setCircleDimmedLayer(false);
                //添加 裁剪参数
                uCrop.withOptions(options);

                //TODO 跳转裁剪页面
                uCrop.start(this);
            }else{
                mPhotoTag = 0;
            }
        }

        //TODO 裁剪后的图片
        if (requestCode == UCrop.REQUEST_CROP) {
            /**
             * 判断 当前 是否真正的 对图片进行了裁剪
             * true：
             *        1.则获取 裁剪后 图片的地址
             *        2.判断是否为null
             *        3.添加到对应Tag的控件上
             *        4.开始上传图片文件
             *
             * false：初始化默认上传 图片 Tag
             *
             */
            if (resultCode == RESULT_OK){
                //获取 裁剪后 图片的 Uri
                Uri resultUri = UCrop.getOutput(data);
                if (resultUri != null) {
                    switch (mPhotoTag) {
                        case 1:         //本人手持
                            FrescoUtils.loadAvatar(resultUri, svCardHand);
                            pvCardHand.setProgress(0);
                            break;
                    }
                    //开始上传文件
                    uploadFile(resultUri);
                } else {
                    mPhotoTag = 0;
                }
            }else{
                mPhotoTag = 0;
            }
        }
        //TODO 裁剪图片 出错
        else if (resultCode == UCrop.RESULT_ERROR) {
            final Throwable cropError = UCrop.getError(data);
            mPhotoTag = 0;
            ToastUtils.showShort(this, "图片裁剪时出错！可能当前设备不支持裁剪！");
        }
    }

    /**
     * 身份证 识别
     *
     * @param idCardSide
     * @param filePath
     */
    private void recIDCard(final String idCardSide, final String filePath) {
        IDCardParams param = new IDCardParams();
        param.setImageFile(new File(filePath));
        // 设置身份证正反面
        param.setIdCardSide(idCardSide);
        // 设置方向检测
        param.setDetectDirection(true);
        // 设置图像参数压缩质量0-100, 越大图像质量越好但是请求时间越长。 不设置则默认值为20
        param.setImageQuality(20);

        OCR.getInstance().recognizeIDCard(param, new OnResultListener<IDCardResult>() {
            @Override
            public void onResult(IDCardResult result) {

                Word number = result.getIdNumber();
                Word authority = result.getIssueAuthority();

                if (number!=null && !"".equals(number.toString()) || authority!=null) {
                    //保存图片位置
                    File file = null;
                    //传入图片存储目录
                    if (IDCardParams.ID_CARD_SIDE_FRONT.equals(idCardSide)) {        //正面
                        file = FileUtils.getSaveFile(getApplication(), mIdCardFrontPath);
                    } else {  //反面
                        file = FileUtils.getSaveFile(getApplication(), mIdCardBackPath);
                    }
                    //将 File 流转换 为 Uri
                    Uri uri = Uri.fromFile(file);
                    //上传身份证图片
                    uploadFile(uri);
                    /**
                     * 判断 身份证 正反面，设置 不同的数据
                     *
                     * true： 正面
                     * false：反面
                     */
                    if (idCardSide.equals(IDCardParams.ID_CARD_SIDE_FRONT)) {
                        //加载图片到 控件上
                        FrescoUtils.loadAvatar(uri, svCardPositive);
                        //提取身份证号
                        mIdCard.setId(result.getIdNumber() + "");
                        //提取身份证 姓名
                        mIdCard.setName(result.getName() + "");
                        //提取身份证 性别
                        mIdCard.setSex(result.getGender() + "");
                        //提取身份证 民族
                        mIdCard.setNation(result.getEthnic() + "");
                        //提取身份证 生日
                        mIdCard.setBirthday(result.getBirthday() + "");
                        //提取身份证 住址
                        mIdCard.setAddress(result.getAddress() + "");
                    } else {
                        //提取签证机关
                        mIdCard.setIssue(result.getIssueAuthority() + "");
                        //提取有效期限
                        mIdCard.setTerm(result.getSignDate() + " - " + result.getExpiryDate());
                        //加载图片到 控件上
                        FrescoUtils.loadAvatar(uri, svCardRelative);
                    }
                } else {
                    //初始化Tag
                    mPhotoTag = 0;
                    //业务逻辑判断
                    if (idCardSide.equals(IDCardParams.ID_CARD_SIDE_FRONT))
                        ToastUtils.showShort(UnicomCardActivity.this, "不是有效的身份证 “正面” 图片！");
                    else
                        ToastUtils.showShort(UnicomCardActivity.this, "不是有效的身份证 “背面” 图片！");
                }
            }

            @Override
            public void onError(OCRError error) {
                //初始化Tag
                mPhotoTag = 0;
                //消息提示
                ToastUtils.showShort(UnicomCardActivity.this, "不是有效的身份证图片！");
            }
        });
    }

    /**
     * 文件上传 带进度 （okHttp）
     *
     * @param uri
     */
    private void uploadFile(final Uri uri) {
        //获取 要上传的 文件 path
        String filePath = FileUtils.getRealFilePath(UnicomCardActivity.this, uri);
        //添加要上传的文件
        File uploadFile = new File(filePath);
        //要上传的 地址
        String url = Constant.HTTP_URL + "TelCardOrder/AppUploadCertifiedInfoPic";

        //TODO 创建一个 okHttp 请求
        OkHttpClient okHttpClient = new OkHttpClient();

        //TODO 创建 一个 bodyBuilder
        MultipartBody.Builder bodyBuilder = new MultipartBody.Builder();
        bodyBuilder.setType(MultipartBody.FORM);

        //文件...参数name指的是请求路径中所接受的参数...如果路径接收参数键值是file
        //此处应该改变
        bodyBuilder.addFormDataPart("file", uploadFile.getName(), RequestBody.create
                (MediaType.parse("application/octet-stream"), uploadFile));
        //构建
        MultipartBody multipartBody = bodyBuilder.build();

        //TODO  获取 上传进度
        RequestBody requestBody = ProgressHelper.withProgress(multipartBody, new ProgressUIListener() {
            @Override
            public void onUIProgressStart(long totalBytes) {
                super.onUIProgressStart(totalBytes);
                LogUtils.i("uploadFile：--------------->开始上传");
                /**
                 * 判断显示那个 上传进度View
                 */
                switch (mPhotoTag) {

                    case 1:         //本人手持
                        pvCardHand.setVisibility(View.VISIBLE);
                        break;

                    case 2:         //正面
                        pvCardPositive.setVisibility(View.VISIBLE);
                        break;

                    case 3:         //反面
                        pvCardRelative.setVisibility(View.VISIBLE);
                        break;
                }
            }

            @Override
            public void onUIProgressChanged(long numBytes, long totalBytes, final float percent, float speed) {
                /**
                 * 判断显示那个 上传进度 百分比
                 */
                switch (mPhotoTag) {

                    case 1:         //本人手持
                        pvCardHand.setProgress((int) (100 * percent));
                        break;

                    case 2:         //正面
                        pvCardPositive.setProgress((int) (100 * percent));
                        break;

                    case 3:         //反面
                        pvCardRelative.setProgress((int) (100 * percent));
                        break;
                }
            }

            @Override
            public void onUIProgressFinish() {
                super.onUIProgressFinish();
                LogUtils.i("uploadFile：--------------->结束上传");
            }
        });

        //创建Request
        Request request = new Request.Builder().url(url).post(requestBody).build();

        //TODO 获取当前网络请求状态
        Call call = okHttpClient.newCall(request);
        call.enqueue(new Callback() {
            //请求出错
            @Override
            public void onFailure(Call call, IOException e) {
                e.printStackTrace();
            }

            //请求成功 返回结果
            @Override
            public void onResponse(Call call, Response response) throws IOException {
                //得到服务器返回的具体内容
                String responseData = response.body().string();
                //开始解析 转换为 实体数据
                Gson gson = new Gson();
                UploadImage image = gson.fromJson(responseData + "", UploadImage.class);

                //TODO 业务逻辑判断
                if (image.getState().equals("1")) {
                    /**
                     * 判断是 那个 Url，并相应的附上值
                     */
                    switch (mPhotoTag) {

                        case 1:         //本人手持
                            mPeoPleSrc = image.getSrc();
                            break;

                        case 2:         //正面
                            mFrontSrc = image.getSrc();
                            break;

                        case 3:         //反面
                            mBackSrc = image.getSrc();
                            break;
                    }
                    //初始化 tag
                    mPhotoTag = 0;
                } else {
                    ToastUtils.showShort(UnicomCardActivity.this, image.getMsg());
                }

            }
        });
    }

    /**
     * 刷新 余额信息 信息
     */
    @Subscriber(tag = Constant.BUS_MY_REMAINDER)
    public void onMyRemainderPush(double money) {
        //TODO 更新 店铺实体 余额
        mACacheUser.setRemainder(money);
    }

    /**
     * 极光推送 店铺 冻结结果
     */
    @Subscriber(tag = Constant.BUS_JPUSH_SHOP_FROZEN_TAG)
    public void onJpushShopFrozenTag(String pushTag) {
        //设置新的 店铺冻结结果
        mACacheUser.setState(pushTag);
    }

    /**
     * 接收 支付密码已经设置成功的推送
     */
    @Subscriber(tag = Constant.BUS_PAY_SET_UP_PWD_YES)
    public void onPaySetUpPwdYes(final String payNewPwd) {
        //设置新的支付密码
        mACacheUser.setTsPwd(payNewPwd);
    }

    /**
     * 获取 iccid
     */
    @Subscriber(tag = Constant.BUS_HOME_ICCID_LIST)
    public void onIccidList(final List<Iccid> list) {

        //TODO 列表非空判断
        if (list != null && list.size() != 0) {
            //新建 list 数组，把详情名称提取出来
            final List<String> iccids = new ArrayList<>();
            //循环提取数据
            for (int i = 0; i < list.size(); i++) {
                iccids.add(list.get(i).getICCID());
            }
            //TODO 填充数据 到下拉列表中
            spinnerNumberIccid.setItems(iccids);
            //设置 下拉列表最大高度
            if (iccids.size()>0)
                spinnerNumberIccid.setDropdownMaxHeight(500);

            //获取 默认的 iccid
            mIccid = iccids.get(0);

            //TODO iccid 监听事件
            spinnerNumberIccid.setOnItemSelectedListener(new MaterialSpinner.OnItemSelectedListener<String>() {
                @Override
                public void onItemSelected(MaterialSpinner view, int position, long id, String item) {
                    //获取 第 i 个 号卡套餐 详情
                    mIccid = iccids.get(position);
                }
            });
        }
    }


    /**
     * 响应 提交 电话卡订单 ------> 联通、170 出错
     */
    @Subscriber(tag = Constant.BUS_HOME_UNICOM_SUBMIT_ERROR)
    public void onUnicomSubmitError(String strError) {
        //延时 1s
        new Handler().postDelayed(new Runnable() {
            @Override
            public void run() {
                //销毁弹窗
                timeDialog.dismiss();
                //弹出提示
                ToastUtils.showShort(UnicomCardActivity.this, "网络连接不稳定，请稍后再试！");
            }
        }, 1000);
    }

    /**
     * 加载 提交 电话卡订单 ------> 联通、170 返回结果
     */
    @Subscriber(tag = Constant.BUS_HOME_UNICOM_SUBMIT)
    public void onUnicomSubmit(final OrderState state) {
        //延时 1s
        new Handler().postDelayed(new Runnable() {
            @Override
            public void run() {
                //销毁弹窗
                timeDialog.dismiss();
                //获取当前订单信息
                mOrderState = state;
                //设置当前订单已经支付过了
                mOrderFlag = true;
                //返回值判断
                if (state.getState().equals("1")) {
                    //弹出支付软件盘
                    setShowPayPopupView("号卡订单支付", state.getPrice());
                }
                //弹出提示
                ToastUtils.showShort(UnicomCardActivity.this, state.getMsg());
            }
        }, 1000);
    }


    /**
     * 显示 支付视图弹窗
     */
    private void setShowPayPopupView(String title,double money) {

        //TODO 配置弹窗
        mPopPayPwd = new PopEnterPassword(UnicomCardActivity.this,title,money) {
            //输入支付密码完成后，所要进行的操作
            @Override
            public void setOnFinishInput(String pwd) {
                //显示进度弹窗
                initShowTimeDialog("正在验证支付密钥，请稍后....", UnicomCardActivity.this);
                //开始验证支付密码
                mApiUserManager.userCardCheckPayPwd(mACacheUser.getId(),pwd);
            }
        };

        /**
         * 显示 支付窗口
         * ps：设置 “Gravity” layout在PopupWindow中显示的位置
         */
        mPopPayPwd.showAtLocation(UnicomCardActivity.this.findViewById(R.id.layout_unicom_card),
                Gravity.BOTTOM | Gravity.CENTER_HORIZONTAL, 0, 0);
    }

    /**
     * 验证支付 报错
     */
    @Subscriber(tag = Constant.BUS_MY_CARD_CHECK_PAY_ERROR, mode = ThreadMode.MAIN)
    public void initCheckPayError(String strError) {
        new Handler().postDelayed(new Runnable() {
            @Override
            public void run() {
                //销毁加载提示框
                timeDialog.dismiss();
                //弹出提示
                ToastUtils.showShort(UnicomCardActivity.this,"支付密钥验证失败，网络连接不稳定！");
            }
        }, 2000);
    }

    /**
     * 验证支付
     */
    @Subscriber(tag = Constant.BUS_MY_CARD_CHECK_PAY, mode = ThreadMode.MAIN)
    public void initCheckPay(final State state) {
        new Handler().postDelayed(new Runnable() {
            @Override
            public void run() {
                //TODO 判断当前是否验证成功
                if (state.getState().equals("1")){
                    //设置 支付标题
                    timeDialog.setContent("正在支付，请稍后...");
                    //开始支付网络请求
                    mApiUserManager.userCardPay(mACacheUser.getId(),mOrderState.getOrderId());
                }else{
                    //销毁加载提示框
                    timeDialog.dismiss();
                    //显示提示信息 dialog
                    new MaterialDialog.Builder(UnicomCardActivity.this)
                            .content("支付密码错误，请重试")
                            .negativeText("重试")
                            .negativeColor(Color.parseColor("#cccccc"))
                            .onNegative(new MaterialDialog.SingleButtonCallback() {
                                @Override
                                public void onClick(@NonNull MaterialDialog dialog, @NonNull DialogAction which) {
                                    //弹出支付软件盘
                                    setShowPayPopupView("号卡订单支付", mOrderState.getPrice());
                                }
                            })
                            .positiveText("忘记密码")
                            .onPositive(new MaterialDialog.SingleButtonCallback() {
                                @Override
                                public void onClick(MaterialDialog dialog, DialogAction which) {
                                    //跳转 忘记支付密码 页面
                                    JumperUtils.JumpTo(UnicomCardActivity.this, PayForgetPwdActivity.class);
                                }
                            }).show();
                }
            }
        }, 2000);
    }

    /**
     * 号卡订单 支付 报错
     */
    @Subscriber(tag = Constant.BUS_MY_CARD_ORDER_PAY_ERROR, mode = ThreadMode.MAIN)
    public void initCardPayError(String httpInstallError) {
        new Handler().postDelayed(new Runnable() {
            @Override
            public void run() {
                //销毁加载弹窗
                timeDialog.dismiss();
                //弹出提示
                ToastUtils.showShort(UnicomCardActivity.this,"支付失败，网络连接不稳定！");
            }
        }, 2000);
    }

    /**
     * 号卡订单 支付 数据返回
     */
    @Subscriber(tag = Constant.BUS_MY_CARD_ORDER_PAY, mode = ThreadMode.MAIN)
    public void initCardPay(final OrderPayState bean) {
        new Handler().postDelayed(new Runnable() {
            @Override
            public void run() {
                //销毁加载弹窗
                timeDialog.dismiss();
                //TODO 支付结果判断
                switch (bean.getState()){

                    //支付成功
                    case "1":
                        //保存新的 用户余额参数
                        mACacheUser.setRemainder(bean.getRemainder());
                        mACache.put(Constant.CACHE_USER, new Gson().toJson(mACacheUser));
                        //更新我的页面 余额
                        EventBus.getDefault().post(bean.getRemainder(),Constant.BUS_MY_REMAINDER);
                        //显示提示信息 dialog
                        initShowMsgDialog();
                        break;
                    //余额不足
                    case "2":

                        break;
                }
                //消息提示
                ToastUtils.showShort(UnicomCardActivity.this,bean.getMsg());
            }
        }, 2000);
    }

    /**
     * 显示提示dialog
     */
    public void initShowMsgDialog() {
        //显示提示信息 dialog
        MaterialDialog dialog = new MaterialDialog.Builder(UnicomCardActivity.this)
                .title("支付成功")
                .content("订单支付成功，可在我的订单查看详情！")
                .positiveText("我知道了")
                .onPositive(new MaterialDialog.SingleButtonCallback() {
                    @Override
                    public void onClick(MaterialDialog dialog, DialogAction which) {
                        //更新号卡页面数据
                        EventBus.getDefault().post("pushSale", Constant.BUS_SALE_PUSH_UI);
                        //退出当前页面
                        finish();
                    }
                }).show();
        // 设置点击屏幕Dialog不消失
        dialog.setCanceledOnTouchOutside(false);
        //取消Back键监听
        dialog.setCancelable(false);
    }
}
